home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / GenTabs.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  41KB  |  1,391 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_General
  4. #include "General.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Memory
  8. #include "Memory.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_DynArray
  12. #include "DynArray.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_StringMem
  20. #include "StringMem.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Times
  24. #include "Times.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Sets
  28. #include "Sets.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_IO
  32. #include "IO.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Layout
  36. #include "Layout.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_DefTable
  40. #include "DefTable.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Tree
  44. #include "Tree.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Nfa
  48. #include "Nfa.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Dfa
  52. #include "Dfa.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Traces
  56. #include "Traces.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_ScanTabs
  60. #include "ScanTabs.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_ScanGen
  64. #include "ScanGen.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_Classes
  68. #include "Classes.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_Strings
  72. #include "Strings.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_Idents
  76. #include "Idents.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_GenTabs
  80. #include "GenTabs.h"
  81. #endif
  82.  
  83. Tree_tTree GenTabs_Root;
  84. SHORTINT GenTabs_NodeCount, GenTabs_StartStateCount;
  85. SHORTCARD GenTabs_RuleCount, GenTabs_PatternCount, GenTabs_LeafCount;
  86. BOOLEAN GenTabs_LeftJustUsed;
  87. SHORTCARD GenTabs_EobAction, GenTabs_DefaultAction;
  88. GenTabs_PatternTable *GenTabs_PatternTablePtr;
  89. LONGINT GenTabs_PatternTableSize;
  90. GenTabs_RuleToCode *GenTabs_RuleToCodePtr;
  91. LONGINT GenTabs_RuleToCodeSize;
  92.  
  93. typedef struct S_1 *SetOfNInfoPtr;
  94. typedef struct S_1 {
  95.     SetOfNInfoPtr Next;
  96.     Sets_tSet Set;
  97.     Dfa_DStateRange DState;
  98. } SetOfNInfo;
  99. typedef struct S_2 {
  100.     SetOfNInfoPtr A[100000 + 1];
  101. } MapDToSetOfN;
  102. typedef struct S_3 {
  103.     SetOfNInfoPtr A[100000 + 1];
  104. } HashDToSetOfN;
  105. typedef struct S_4 {
  106.     Dfa_DStateRange A[100000 + 1];
  107. } Stack;
  108. static MapDToSetOfN *MapDToSetOfNPtr;
  109. static LONGINT MapDToSetOfNSize;
  110. static HashDToSetOfN *HashDToSetOfNPtr;
  111. static LONGINT HashDToSetOfNSize;
  112. static Stack *StackPtr;
  113. static LONGINT StackSize;
  114. static Dfa_DStateRange StackTop;
  115. static Sets_tSet StartSet, dSemantics;
  116. static INTEGER SentinelSavings;
  117. static BOOLEAN IsComputedNContext;
  118. static BOOLEAN IsComputedDContext;
  119. static BOOLEAN IsComputedFinals;
  120. static void ComputeNfa ARGS(());
  121. static SHORTINT ComputeLength ARGS((Tree_tTree t));
  122. static void AttributeEvaluator ARGS((Tree_tTree t, Nfa_TransitionRange *Transitions, Sets_tSet *FinalStates, BOOLEAN *IsOptional));
  123. static Nfa_TransitionRange tt;
  124. static SHORTCARD PatternNr;
  125. static void ExtendTransitions ARGS((CARDINAL NState));
  126. static void EnterNSemantics ARGS((CARDINAL NState));
  127. static Dfa_DStateRange MapSetOfNToD ARGS((Sets_tSet t));
  128. static void ComputeDfa ARGS(());
  129. #define InitialStackSize    64
  130. struct S_5 {
  131.     Sets_tSet A[256];
  132. };
  133. static Dfa_DStateRange dState;
  134. static void EnterDSemantics ARGS((CARDINAL NState));
  135. static void SaveSentinels ARGS(());
  136. static void AddConstantREs ARGS(());
  137. static void ComputeConstantRE ARGS((Tree_tTree t, Strings_tString *String));
  138. static void AddConstantRE ARGS((Dfa_DStateRange StartState, Strings_tString String, SHORTCARD PatternNr, Sets_tSet StartStates));
  139. static CHAR GetCh ARGS(());
  140. static void UpdateContext ARGS(());
  141. static void InvertMapping ARGS(());
  142. static void CheckTables ARGS(());
  143. static void CheckStartState ARGS((SHORTCARD StartState, Idents_tIdent Ident, BOOLEAN LeftJust));
  144. static void WritePattern ARGS(());
  145. static void WriteStatistics ARGS(());
  146.  
  147. static SHORTCARD *G_1_ChIndex;
  148. static SHORTCARD *G_2_StringLength;
  149. static BOOLEAN *G_3_EndOfInput;
  150. static Strings_tString *G_4_String;
  151.  
  152. static void ComputeNfa
  153. # ifdef __STDC__
  154. ()
  155. # else
  156. ()
  157. # endif
  158. {
  159.   Nfa_TransitionRange t1, t2;
  160.   Sets_tSet f1, f2;
  161.   BOOLEAN o1, o2;
  162.   Tree_tTree ruleList;
  163.   Tree_tTree rule;
  164.   Tree_tTree patternList;
  165.   Tree_tTree pattern;
  166.   SHORTCARD RuleNr;
  167.   Nfa_NStateRange NState;
  168.   SHORTINT length;
  169.  
  170.   Nfa_BeginNfa();
  171.   {
  172.     LONGINT B_1 = 1, B_2 = GenTabs_StartStateCount;
  173.  
  174.     if (B_1 <= B_2)
  175.       for (NState = B_1;; NState += 1) {
  176.         if (Nfa_MakeNState((LONGINT)Nfa_NoTransition) != NState) {
  177.           exit(1);
  178.         }
  179.         if (NState >= B_2) break;
  180.       }
  181.   }
  182.   Sets_MakeSet(&f1, (LONGCARD)GenTabs_LeafCount);
  183.   Sets_MakeSet(&f2, (LONGCARD)GenTabs_LeafCount);
  184.   ruleList = GenTabs_Root;
  185.   while (ruleList != Tree_NoTree) {
  186.     rule = ruleList->U_1.V_3.vNode2.Son2;
  187.     RuleNr = rule->U_1.V_7.vNodeRule.RuleNr;
  188.     GenTabs_RuleToCodePtr->A[RuleNr].Text = rule->U_1.V_7.vNodeRule.TargetCode;
  189.     GenTabs_RuleToCodePtr->A[RuleNr].TextLine = rule->U_1.V_7.vNodeRule.Line;
  190.     GenTabs_RuleToCodePtr->A[RuleNr].CodeMode = rule->U_1.V_7.vNodeRule.CodeMode;
  191.     patternList = rule->U_1.V_7.vNodeRule.Patterns;
  192.     while (patternList != Tree_NoTree) {
  193.       pattern = patternList->U_1.V_3.vNode2.Son2;
  194.       PatternNr = pattern->U_1.V_8.vNodePattern.PatternNr;
  195.       {
  196.         register GenTabs_PatternInfo *W_1 = &GenTabs_PatternTablePtr->A[PatternNr];
  197.  
  198.         W_1->Rule = RuleNr;
  199.         W_1->ContextLng = GenTabs_NoContext;
  200.         W_1->Position = pattern->U_1.V_8.vNodePattern.Position;
  201.       }
  202.       if (!pattern->U_1.V_8.vNodePattern.IsConstantRE) {
  203.         AttributeEvaluator(pattern->U_1.V_8.vNodePattern.RegExpr, &t1, &f1, &o1);
  204.         AttributeEvaluator(pattern->U_1.V_8.vNodePattern.RightContext, &t2, &f2, &o2);
  205.         tt = t1;
  206.         Sets_ForallDo(pattern->U_1.V_8.vNodePattern.StartStates, (Sets_ProcOfCard)ExtendTransitions);
  207.         if (o2) {
  208.           Sets_ForallDo(f1, (Sets_ProcOfCard)EnterNSemantics);
  209.         }
  210.         tt = t2;
  211.         Sets_ForallDo(f1, (Sets_ProcOfCard)ExtendTransitions);
  212.         Sets_ForallDo(f2, (Sets_ProcOfCard)EnterNSemantics);
  213.         length = ComputeLength(pattern->U_1.V_8.vNodePattern.RightContext);
  214.         if (length != GenTabs_VariableContext) {
  215.           GenTabs_PatternTablePtr->A[PatternNr].ContextLng = length;
  216.         } else {
  217.           length = ComputeLength(pattern->U_1.V_8.vNodePattern.RegExpr);
  218.           if (length != GenTabs_VariableContext) {
  219.             GenTabs_PatternTablePtr->A[PatternNr].ContextLng = -length;
  220.           } else {
  221.             GenTabs_PatternTablePtr->A[PatternNr].ContextLng = GenTabs_VariableContext;
  222.             Sets_MakeSet(&GenTabs_PatternTablePtr->A[PatternNr].NContext, (LONGCARD)GenTabs_LeafCount);
  223.             Sets_Assign(&GenTabs_PatternTablePtr->A[PatternNr].NContext, f1);
  224.           }
  225.         }
  226.       }
  227.       patternList = patternList->U_1.V_3.vNode2.Son1;
  228.     }
  229.     ruleList = ruleList->U_1.V_3.vNode2.Son1;
  230.   }
  231.   IsComputedNContext = TRUE;
  232.   Sets_ReleaseSet(&f1);
  233.   Sets_ReleaseSet(&f2);
  234. }
  235.  
  236. static SHORTINT ComputeLength
  237. # ifdef __STDC__
  238. (Tree_tTree t)
  239. # else
  240. (t)
  241. Tree_tTree t;
  242. # endif
  243. {
  244.   SHORTINT l1, l2;
  245.   Strings_tString string;
  246.  
  247.   if (t == Tree_NoTree) {
  248.     return GenTabs_NoContext;
  249.   }
  250.   switch (t->U_1.V_1.vNode0.Rule) {
  251.   case Tree_nAlternative:;
  252.     l1 = ComputeLength(t->U_1.V_3.vNode2.Son1);
  253.     l2 = ComputeLength(t->U_1.V_3.vNode2.Son2);
  254.     if (l1 == l2) {
  255.       return l1;
  256.     } else {
  257.       return GenTabs_VariableContext;
  258.     }
  259.     break;
  260.   case Tree_nSequence:;
  261.     l1 = ComputeLength(t->U_1.V_3.vNode2.Son1);
  262.     l2 = ComputeLength(t->U_1.V_3.vNode2.Son2);
  263.     if (l1 != GenTabs_VariableContext && l2 != GenTabs_VariableContext) {
  264.       return l1 + l2;
  265.     } else {
  266.       return GenTabs_VariableContext;
  267.     }
  268.     break;
  269.   case Tree_nRepetition:;
  270.   case Tree_nOption:;
  271.     return GenTabs_VariableContext;
  272.     break;
  273.   case Tree_nChar:;
  274.   case Tree_nSet:;
  275.     return 1;
  276.     break;
  277.   case Tree_nString:;
  278.     StringMem_GetString(t->U_1.V_6.vNodeString.String, &string);
  279.     return Strings_Length(&string);
  280.     break;
  281.   }
  282. }
  283.  
  284. static void AttributeEvaluator
  285. # ifdef __STDC__
  286. (Tree_tTree t, Nfa_TransitionRange *Transitions, Sets_tSet *FinalStates, BOOLEAN *IsOptional)
  287. # else
  288. (t, Transitions, FinalStates, IsOptional)
  289. Tree_tTree t;
  290. Nfa_TransitionRange *Transitions;
  291. Sets_tSet *FinalStates;
  292. BOOLEAN *IsOptional;
  293. # endif
  294. {
  295.   Nfa_TransitionRange t1, t2;
  296.   Sets_tSet f1, f2;
  297.   BOOLEAN o1, o2;
  298.   Nfa_NStateRange NState;
  299.   Strings_tString string;
  300.   CARDINAL i;
  301.  
  302.   if (t == Tree_NoTree) {
  303.     *Transitions = Nfa_NoTransition;
  304.     Sets_AssignEmpty(FinalStates);
  305.     *IsOptional = TRUE;
  306.     return;
  307.   }
  308.   switch (t->U_1.V_1.vNode0.Rule) {
  309.   case Tree_nAlternative:;
  310.     Sets_MakeSet(&f1, (LONGCARD)GenTabs_LeafCount);
  311.     Sets_MakeSet(&f2, (LONGCARD)GenTabs_LeafCount);
  312.     AttributeEvaluator(t->U_1.V_3.vNode2.Son1, &t1, &f1, &o1);
  313.     AttributeEvaluator(t->U_1.V_3.vNode2.Son2, &t2, &f2, &o2);
  314.     *Transitions = Nfa_UniteTransitions(t1, t2);
  315.     Sets_Assign(FinalStates, f1);
  316.     Sets_Union(FinalStates, f2);
  317.     *IsOptional = o1 || o2;
  318.     Sets_ReleaseSet(&f1);
  319.     Sets_ReleaseSet(&f2);
  320.     break;
  321.   case Tree_nSequence:;
  322.     Sets_MakeSet(&f1, (LONGCARD)GenTabs_LeafCount);
  323.     Sets_MakeSet(&f2, (LONGCARD)GenTabs_LeafCount);
  324.     AttributeEvaluator(t->U_1.V_3.vNode2.Son1, &t1, &f1, &o1);
  325.     AttributeEvaluator(t->U_1.V_3.vNode2.Son2, &t2, &f2, &o2);
  326.     tt = t2;
  327.     Sets_ForallDo(f1, (Sets_ProcOfCard)ExtendTransitions);
  328.     if (o1) {
  329.       *Transitions = Nfa_UniteTransitions(t1, t2);
  330.     } else {
  331.       *Transitions = t1;
  332.     }
  333.     if (o2) {
  334.       Sets_Assign(FinalStates, f1);
  335.       Sets_Union(FinalStates, f2);
  336.     } else {
  337.       Sets_Assign(FinalStates, f2);
  338.     }
  339.     *IsOptional = o1 && o2;
  340.     Sets_ReleaseSet(&f1);
  341.     Sets_ReleaseSet(&f2);
  342.     break;
  343.   case Tree_nRepetition:;
  344.     Sets_MakeSet(&f1, (LONGCARD)GenTabs_LeafCount);
  345.     AttributeEvaluator(t->U_1.V_2.vNode1.Son1, &t1, &f1, &o1);
  346.     tt = t1;
  347.     Sets_ForallDo(f1, (Sets_ProcOfCard)ExtendTransitions);
  348.     *Transitions = t1;
  349.     Sets_Assign(FinalStates, f1);
  350.     *IsOptional = o1;
  351.     Sets_ReleaseSet(&f1);
  352.     break;
  353.   case Tree_nOption:;
  354.     Sets_MakeSet(&f1, (LONGCARD)GenTabs_LeafCount);
  355.     AttributeEvaluator(t->U_1.V_2.vNode1.Son1, &t1, &f1, &o1);
  356.     *Transitions = t1;
  357.     Sets_Assign(FinalStates, f1);
  358.     *IsOptional = TRUE;
  359.     Sets_ReleaseSet(&f1);
  360.     break;
  361.   case Tree_nChar:;
  362.     NState = Nfa_MakeNState((LONGINT)Nfa_NoTransition);
  363.     *Transitions = Nfa_MakeTransition(t->U_1.V_4.vNodeCh.Ch, NState);
  364.     Sets_AssignElmt(FinalStates, (LONGCARD)NState);
  365.     *IsOptional = FALSE;
  366.     break;
  367.   case Tree_nSet:;
  368.     Sets_MakeSet(&f1, ORD(Dfa_LastCh));
  369.     Sets_Assign(&f1, t->U_1.V_5.vNodeSet.Set);
  370.     NState = Nfa_MakeNState((LONGINT)Nfa_NoTransition);
  371.     *Transitions = Nfa_NoTransition;
  372.     while (!Sets_IsEmpty(f1)) {
  373.       *Transitions = Nfa_AddTransition(Nfa_MakeTransition(CHR(Sets_Extract(&f1)), NState), *Transitions);
  374.     }
  375.     Sets_AssignElmt(FinalStates, (LONGCARD)NState);
  376.     *IsOptional = FALSE;
  377.     Sets_ReleaseSet(&f1);
  378.     break;
  379.   case Tree_nString:;
  380.     StringMem_GetString(t->U_1.V_6.vNodeString.String, &string);
  381.     NState = Nfa_MakeNState((LONGINT)Nfa_NoTransition);
  382.     *Transitions = Nfa_MakeTransition(Strings_Char(&string, (Strings_tStringIndex)Strings_Length(&string)), NState);
  383.     Sets_AssignElmt(FinalStates, (LONGCARD)NState);
  384.     for (i = Strings_Length(&string) - 1; i >= 1; i += -1) {
  385.       NState = Nfa_MakeNState(*Transitions);
  386.       *Transitions = Nfa_MakeTransition(Strings_Char(&string, (Strings_tStringIndex)i), NState);
  387.     }
  388.     *IsOptional = FALSE;
  389.     break;
  390.   }
  391. }
  392.  
  393. static void ExtendTransitions
  394. # ifdef __STDC__
  395. (CARDINAL NState)
  396. # else
  397. (NState)
  398. CARDINAL NState;
  399. # endif
  400. {
  401.   Nfa_PutTransitions((LONGINT)NState, Nfa_UniteTransitions(Nfa_GetTransitions((LONGINT)NState), Nfa_CopyTransitions(tt)));
  402. }
  403.  
  404. static void EnterNSemantics
  405. # ifdef __STDC__
  406. (CARDINAL NState)
  407. # else
  408. (NState)
  409. CARDINAL NState;
  410. # endif
  411. {
  412.   Nfa_PutNSemantics((LONGINT)NState, PatternNr);
  413. }
  414.  
  415. static Dfa_DStateRange MapSetOfNToD
  416. # ifdef __STDC__
  417. (Sets_tSet t)
  418. # else
  419. (t)
  420. Sets_tSet t;
  421. # endif
  422. {
  423.   Dfa_DStateRange DState;
  424.   CARDINAL Hash;
  425.   SetOfNInfoPtr Current;
  426.  
  427.   Hash = Sets_Maximum(&t) % (CARDINAL)Nfa_NStateCount;
  428.   Current = HashDToSetOfNPtr->A[Hash];
  429.   while (Current != NIL) {
  430.     if (Sets_IsEqual(&Current->Set, &t)) {
  431.       return Current->DState;
  432.     }
  433.     Current = Current->Next;
  434.   }
  435.   DState = Dfa_MakeDState();
  436.   if (DState == MapDToSetOfNSize) {
  437.     DynArray_ExtendArray((ADDRESS *)&MapDToSetOfNPtr, &MapDToSetOfNSize, (LONGINT)sizeof(SetOfNInfoPtr));
  438.   }
  439.   MapDToSetOfNPtr->A[DState] = (SetOfNInfoPtr)Memory_Alloc((LONGINT)sizeof(SetOfNInfo));
  440.   Sets_MakeSet(&MapDToSetOfNPtr->A[DState]->Set, (LONGCARD)Nfa_NStateCount);
  441.   Sets_Assign(&MapDToSetOfNPtr->A[DState]->Set, t);
  442.   MapDToSetOfNPtr->A[DState]->DState = DState;
  443.   MapDToSetOfNPtr->A[DState]->Next = HashDToSetOfNPtr->A[Hash];
  444.   HashDToSetOfNPtr->A[Hash] = MapDToSetOfNPtr->A[DState];
  445.   INC(StackTop);
  446.   if (StackTop == StackSize) {
  447.     DynArray_ExtendArray((ADDRESS *)&StackPtr, &StackSize, (LONGINT)sizeof(Dfa_DStateRange));
  448.   }
  449.   StackPtr->A[StackTop] = DState;
  450.   return DState;
  451. }
  452.  
  453. static void ComputeDfa
  454. # ifdef __STDC__
  455. ()
  456. # else
  457. ()
  458. # endif
  459. {
  460.   Dfa_DStateRange DState;
  461.   Nfa_NStateRange NState;
  462.   Sets_tSet x;
  463.   struct S_5 y;
  464.   Nfa_TransitionRange Transition;
  465.   CHAR Ch;
  466.   Sets_tSet CharSet;
  467.   SHORTCARD Pattern;
  468.   Sets_tSet nStates;
  469.  
  470.   StackSize = InitialStackSize;
  471.   DynArray_MakeArray((ADDRESS *)&StackPtr, &StackSize, (LONGINT)sizeof(Dfa_DStateRange));
  472.   StackTop = 0;
  473.   MapDToSetOfNSize = GenTabs_LeafCount;
  474.   DynArray_MakeArray((ADDRESS *)&MapDToSetOfNPtr, &MapDToSetOfNSize, (LONGINT)sizeof(SetOfNInfoPtr));
  475.   HashDToSetOfNSize = Nfa_NStateCount;
  476.   DynArray_MakeArray((ADDRESS *)&HashDToSetOfNPtr, &HashDToSetOfNSize, (LONGINT)sizeof(SetOfNInfoPtr));
  477.   {
  478.     LONGINT B_3 = 0, B_4 = Nfa_NStateCount - 1;
  479.  
  480.     if (B_3 <= B_4)
  481.       for (NState = B_3;; NState += 1) {
  482.         HashDToSetOfNPtr->A[NState] = NIL;
  483.         if (NState >= B_4) break;
  484.       }
  485.   }
  486.   Sets_MakeSet(&x, (LONGCARD)Nfa_NStateCount);
  487.   {
  488.     CHAR B_5 = Dfa_FirstCh, B_6 = Dfa_LastCh;
  489.  
  490.     if (B_5 <= B_6)
  491.       for (Ch = B_5;; Ch += 1) {
  492.         Sets_MakeSet(&y.A[Ch], (LONGCARD)Nfa_NStateCount);
  493.         if (Ch >= B_6) break;
  494.       }
  495.   }
  496.   Sets_MakeSet(&CharSet, ORD(Dfa_LastCh));
  497.   Sets_MakeSet(&nStates, (LONGCARD)GenTabs_LeafCount);
  498.   {
  499.     LONGINT B_7 = 1, B_8 = GenTabs_StartStateCount;
  500.  
  501.     if (B_7 <= B_8)
  502.       for (NState = B_7;; NState += 1) {
  503.         Sets_AssignElmt(&x, (LONGCARD)NState);
  504.         DState = MapSetOfNToD(x);
  505.         if (DState != NState) {
  506.           exit(1);
  507.         }
  508.         if (NState >= B_8) break;
  509.       }
  510.   }
  511.   while (StackTop > 0) {
  512.     DState = StackPtr->A[StackTop];
  513.     DEC(StackTop);
  514.     Sets_Assign(&x, MapDToSetOfNPtr->A[DState]->Set);
  515.     Sets_AssignEmpty(&CharSet);
  516.     {
  517.       LONGINT B_9 = 1, B_10 = Nfa_NStateCount;
  518.  
  519.       if (B_9 <= B_10)
  520.         for (NState = B_9;; NState += 1) {
  521.           if (Sets_IsElement((LONGCARD)NState, &x)) {
  522.             Transition = Nfa_GetTransitions(NState);
  523.             while (!Nfa_IsLastTransition(Transition)) {
  524.               Ch = Nfa_GetCh(Transition);
  525.               Sets_Include(&y.A[Ch], (LONGCARD)Nfa_GetNextState(Transition));
  526.               Sets_Include(&CharSet, ORD(Ch));
  527.               Transition = Nfa_NextTransition(Transition);
  528.             }
  529.           }
  530.           if (NState >= B_10) break;
  531.         }
  532.     }
  533.     while (!Sets_IsEmpty(CharSet)) {
  534.       Ch = CHR(Sets_Extract(&CharSet));
  535.       Dfa_PutTable(DState, Ch, MapSetOfNToD(y.A[Ch]));
  536.       Sets_AssignEmpty(&y.A[Ch]);
  537.     }
  538.   }
  539.   INC1(GenTabs_NodeCount, Dfa_DStateCount + 3);
  540.   {
  541.     SHORTCARD B_11 = 1, B_12 = GenTabs_PatternCount - 2;
  542.  
  543.     if (B_11 <= B_12)
  544.       for (Pattern = B_11;; Pattern += 1) {
  545.         if (GenTabs_PatternTablePtr->A[Pattern].ContextLng == GenTabs_VariableContext) {
  546.           Sets_MakeSet(&GenTabs_PatternTablePtr->A[Pattern].DContext, (LONGCARD)GenTabs_NodeCount);
  547.           {
  548.             SHORTINT B_13 = 1, B_14 = Dfa_DStateCount;
  549.  
  550.             if (B_13 <= B_14)
  551.               for (DState = B_13;; DState += 1) {
  552.                 Sets_Assign(&nStates, GenTabs_PatternTablePtr->A[Pattern].NContext);
  553.                 Sets_Intersection(&nStates, MapDToSetOfNPtr->A[DState]->Set);
  554.                 if (!Sets_IsEmpty(nStates)) {
  555.                   Sets_Include(&GenTabs_PatternTablePtr->A[Pattern].DContext, (LONGCARD)DState);
  556.                 }
  557.                 if (DState >= B_14) break;
  558.               }
  559.           }
  560.           Sets_ReleaseSet(&GenTabs_PatternTablePtr->A[Pattern].NContext);
  561.         }
  562.         if (Pattern >= B_12) break;
  563.       }
  564.   }
  565.   IsComputedNContext = FALSE;
  566.   IsComputedDContext = TRUE;
  567.   {
  568.     SHORTINT B_15 = 1, B_16 = Dfa_DStateCount;
  569.  
  570.     if (B_15 <= B_16)
  571.       for (DState = B_15;; DState += 1) {
  572.         dState = DState;
  573.         Sets_AssignEmpty(&dSemantics);
  574.         Sets_ForallDo(MapDToSetOfNPtr->A[DState]->Set, (Sets_ProcOfCard)EnterDSemantics);
  575.         Sets_Exclude(&dSemantics, (LONGCARD)ScanTabs_NoRule);
  576.         Dfa_PutDSemantics(DState, dSemantics);
  577.         if (DState >= B_16) break;
  578.       }
  579.   }
  580.   {
  581.     SHORTINT B_17 = 1, B_18 = Dfa_DStateCount;
  582.  
  583.     if (B_17 <= B_18)
  584.       for (DState = B_17;; DState += 1) {
  585.         Sets_ReleaseSet(&MapDToSetOfNPtr->A[DState]->Set);
  586.         Memory_Free((LONGINT)sizeof(SetOfNInfo), (ADDRESS)MapDToSetOfNPtr->A[DState]);
  587.         if (DState >= B_18) break;
  588.       }
  589.   }
  590.   Sets_ReleaseSet(&x);
  591.   {
  592.     CHAR B_19 = Dfa_FirstCh, B_20 = Dfa_LastCh;
  593.  
  594.     if (B_19 <= B_20)
  595.       for (Ch = B_19;; Ch += 1) {
  596.         Sets_ReleaseSet(&y.A[Ch]);
  597.         if (Ch >= B_20) break;
  598.       }
  599.   }
  600.   Sets_ReleaseSet(&CharSet);
  601.   Sets_ReleaseSet(&nStates);
  602.   DynArray_ReleaseArray((ADDRESS *)&StackPtr, &StackSize, (LONGINT)sizeof(Dfa_DStateRange));
  603.   DynArray_ReleaseArray((ADDRESS *)&MapDToSetOfNPtr, &MapDToSetOfNSize, (LONGINT)sizeof(SetOfNInfoPtr));
  604.   DynArray_ReleaseArray((ADDRESS *)&HashDToSetOfNPtr, &HashDToSetOfNSize, (LONGINT)sizeof(SetOfNInfoPtr));
  605.   Nfa_FinalizeNfa();
  606. }
  607.  
  608. static void EnterDSemantics
  609. # ifdef __STDC__
  610. (CARDINAL NState)
  611. # else
  612. (NState)
  613. CARDINAL NState;
  614. # endif
  615. {
  616.   Sets_Include(&dSemantics, (LONGCARD)Nfa_GetNSemantics((LONGINT)NState));
  617. }
  618.  
  619. static void SaveSentinels
  620. # ifdef __STDC__
  621. ()
  622. # else
  623. ()
  624. # endif
  625. {
  626.   Dfa_DStateRange DState, Default;
  627.   BOOLEAN Success;
  628.   CHAR Ch, LastCh;
  629.   Sets_tSet Defaults;
  630.  
  631.   SentinelSavings = 0;
  632.   Sets_MakeSet(&Defaults, (LONGCARD)Dfa_DStateCount);
  633.   {
  634.     SHORTINT B_21 = 1, B_22 = Dfa_DStateCount;
  635.  
  636.     if (B_21 <= B_22)
  637.       for (DState = B_21;; DState += 1) {
  638.         Sets_Include(&Defaults, (LONGCARD)Dfa_GetDefault(DState));
  639.         if (DState >= B_22) break;
  640.       }
  641.   }
  642.   {
  643.     SHORTINT B_23 = 1, B_24 = Dfa_DStateCount;
  644.  
  645.     if (B_23 <= B_24)
  646.       for (DState = B_23;; DState += 1) {
  647.         Dfa_GetDSemantics(DState, &dSemantics);
  648.         Default = Dfa_GetDefault(DState);
  649.         if (!Sets_IsEmpty(dSemantics) && (Default == Dfa_DNoState || Default == Dfa_EobDefaultState) && !Sets_IsElement((LONGCARD)DState, &Defaults)) {
  650.           Success = TRUE;
  651.           Ch = Dfa_GetFirst(DState);
  652.           LastCh = Dfa_GetLast(DState);
  653.           if (Ch <= LastCh) {
  654.             for (;;) {
  655.               if (Ch != Classes_ToClass.A[Dfa_EobCh] && Dfa_GetTable(DState, Ch) != Dfa_DNoState) {
  656.                 Success = FALSE;
  657.                 goto EXIT_1;
  658.               }
  659.               if (Ch == LastCh) {
  660.                 goto EXIT_1;
  661.               }
  662.               INC(Ch);
  663.             } EXIT_1:;
  664.           }
  665.           if (Success) {
  666.             Dfa_PutTable(DState, Classes_ToClass.A[Dfa_EobCh], Dfa_DNoState);
  667.             Dfa_PutDefault(DState, Dfa_DNoState);
  668.             INC(SentinelSavings);
  669.           }
  670.         }
  671.         if (DState >= B_24) break;
  672.       }
  673.   }
  674.   Sets_ReleaseSet(&Defaults);
  675. }
  676.  
  677. static void AddConstantREs
  678. # ifdef __STDC__
  679. ()
  680. # else
  681. ()
  682. # endif
  683. {
  684.   Tree_tTree ruleList;
  685.   Tree_tTree rule;
  686.   Tree_tTree patternList;
  687.   Tree_tTree pattern;
  688.   Strings_tString string1, string2;
  689.   Dfa_DStateRange StartState;
  690.   SHORTCARD PatternNr;
  691.  
  692.   Traces_InitTraces();
  693.   Sets_MakeSet(&StartSet, (LONGCARD)GenTabs_StartStateCount);
  694.   ruleList = GenTabs_Root;
  695.   while (ruleList != Tree_NoTree) {
  696.     rule = ruleList->U_1.V_3.vNode2.Son2;
  697.     patternList = rule->U_1.V_7.vNodeRule.Patterns;
  698.     while (patternList != Tree_NoTree) {
  699.       pattern = patternList->U_1.V_3.vNode2.Son2;
  700.       if (pattern->U_1.V_8.vNodePattern.IsConstantRE) {
  701.         PatternNr = pattern->U_1.V_8.vNodePattern.PatternNr;
  702.         GenTabs_PatternTablePtr->A[PatternNr].ContextLng = ComputeLength(pattern->U_1.V_8.vNodePattern.RightContext);
  703.         ComputeConstantRE(pattern->U_1.V_8.vNodePattern.RegExpr, &string1);
  704.         ComputeConstantRE(pattern->U_1.V_8.vNodePattern.RightContext, &string2);
  705.         Strings_Concatenate(&string1, &string2);
  706.         Traces_ResetTraces((LONGINT)Strings_Length(&string1));
  707.         {
  708.           SHORTINT B_25 = 1, B_26 = GenTabs_StartStateCount;
  709.  
  710.           if (B_25 <= B_26)
  711.             for (StartState = B_25;; StartState += 1) {
  712.               if (Sets_IsElement((LONGCARD)StartState, &pattern->U_1.V_8.vNodePattern.StartStates)) {
  713.                 AddConstantRE(StartState, string1, PatternNr, pattern->U_1.V_8.vNodePattern.StartStates);
  714.               }
  715.               if (StartState >= B_26) break;
  716.             }
  717.         }
  718.       }
  719.       patternList = patternList->U_1.V_3.vNode2.Son1;
  720.     }
  721.     ruleList = ruleList->U_1.V_3.vNode2.Son1;
  722.   }
  723.   Sets_ReleaseSet(&StartSet);
  724.   Traces_FinalizeTraces();
  725. }
  726.  
  727. static void ComputeConstantRE
  728. # ifdef __STDC__
  729. (Tree_tTree t, Strings_tString *String)
  730. # else
  731. (t, String)
  732. Tree_tTree t;
  733. Strings_tString *String;
  734. # endif
  735. {
  736.   Strings_tString string2;
  737.  
  738.   if (t == Tree_NoTree) {
  739.     Strings_AssignEmpty(String);
  740.   } else {
  741.     switch (t->U_1.V_1.vNode0.Rule) {
  742.     case Tree_nSequence:;
  743.       ComputeConstantRE(t->U_1.V_3.vNode2.Son1, String);
  744.       ComputeConstantRE(t->U_1.V_3.vNode2.Son2, &string2);
  745.       Strings_Concatenate(String, &string2);
  746.       break;
  747.     case Tree_nChar:;
  748.       Strings_AssignEmpty(String);
  749.       Strings_Append(String, t->U_1.V_4.vNodeCh.Ch);
  750.       break;
  751.     case Tree_nString:;
  752.       StringMem_GetString(t->U_1.V_6.vNodeString.String, String);
  753.       break;
  754.     }
  755.   }
  756. }
  757.  
  758. static CHAR GetCh
  759. # ifdef __STDC__
  760. ()
  761. # else
  762. ()
  763. # endif
  764. {
  765.   if (*G_1_ChIndex == *G_2_StringLength) {
  766.     *G_3_EndOfInput = TRUE;
  767.     return Dfa_FirstCh;
  768.   } else {
  769.     INC(*G_1_ChIndex);
  770.     return Strings_Char(G_4_String, *G_1_ChIndex);
  771.   }
  772. }
  773.  
  774. static void AddConstantRE
  775. # ifdef __STDC__
  776. (Dfa_DStateRange StartState, Strings_tString String, SHORTCARD PatternNr, Sets_tSet StartStates)
  777. # else
  778. (StartState, String, PatternNr, StartStates)
  779. Dfa_DStateRange StartState;
  780. Strings_tString String;
  781. SHORTCARD PatternNr;
  782. Sets_tSet StartStates;
  783. # endif
  784. {
  785.   CHAR Ch;
  786.   Dfa_DStateRange State, Successor, NewState, PrevState;
  787.   SHORTCARD ChIndex;
  788.   SHORTCARD StringLength;
  789.   BOOLEAN EndOfInput;
  790.   SHORTCARD *L_1;
  791.   SHORTCARD *L_2;
  792.   BOOLEAN *L_3;
  793.   Strings_tString *L_4;
  794.  
  795.   L_1 = G_1_ChIndex;
  796.   G_1_ChIndex = &ChIndex;
  797.   L_2 = G_2_StringLength;
  798.   G_2_StringLength = &StringLength;
  799.   L_3 = G_3_EndOfInput;
  800.   G_3_EndOfInput = &EndOfInput;
  801.   L_4 = G_4_String;
  802.   G_4_String = &String;
  803.   StringLength = Strings_Length(&String);
  804.   ChIndex = 0;
  805.   EndOfInput = FALSE;
  806.   State = StartState;
  807.   Ch = GetCh();
  808.   PrevState = State;
  809.   for (;;) {
  810.     if (EndOfInput) {
  811.       goto EXIT_2;
  812.     }
  813.     Successor = Dfa_GetTable(State, Ch);
  814.     if (Successor == Dfa_DNoState) {
  815.       goto EXIT_2;
  816.     }
  817.     if (Successor <= Dfa_MaxAmbiguousState && Sets_IsElement((LONGCARD)Successor, &Dfa_AmbiguousStates)) {
  818.       goto EXIT_2;
  819.     }
  820.     Dfa_GetStartSet(Successor, &StartSet);
  821.     if (!Sets_IsSubset(StartSet, StartStates)) {
  822.       goto EXIT_2;
  823.     }
  824.     State = Successor;
  825.     NewState = Traces_RecordedTrace(ChIndex, State);
  826.     if (NewState != Dfa_DNoState) {
  827.       Dfa_PutTable(PrevState, Ch, NewState);
  828.     } else {
  829.       Traces_RecordTrace(ChIndex, State, State);
  830.       NewState = State;
  831.     }
  832.     Dfa_GetStartSet(NewState, &StartSet);
  833.     Sets_Include(&StartSet, (LONGCARD)StartState);
  834.     Dfa_PutStartSet(NewState, StartSet);
  835.     PrevState = NewState;
  836.     Ch = GetCh();
  837.   } EXIT_2:;
  838.   for (;;) {
  839.     if (EndOfInput) {
  840.       goto EXIT_3;
  841.     }
  842.     Successor = Dfa_GetTable(State, Ch);
  843.     if (Successor != Dfa_DNoState) {
  844.       State = Successor;
  845.       NewState = Traces_RecordedTrace(ChIndex, State);
  846.       if (NewState == Dfa_DNoState) {
  847.         NewState = Dfa_MakeDState();
  848.         Dfa_GetDSemantics(State, &dSemantics);
  849.         Dfa_PutDSemantics(NewState, dSemantics);
  850.         Dfa_PutDefault(NewState, State);
  851.         Traces_RecordTrace(ChIndex, State, NewState);
  852.       }
  853.       Dfa_PutTable(PrevState, Ch, NewState);
  854.       Dfa_GetStartSet(NewState, &StartSet);
  855.       Sets_Include(&StartSet, (LONGCARD)StartState);
  856.       Dfa_PutStartSet(NewState, StartSet);
  857.       PrevState = NewState;
  858.       Ch = GetCh();
  859.     } else {
  860.       if (Dfa_GetDefault(State) == Dfa_DNoState) {
  861.         goto EXIT_3;
  862.       }
  863.       State = Dfa_GetDefault(State);
  864.     }
  865.   } EXIT_3:;
  866.   for (;;) {
  867.     if (EndOfInput) {
  868.       goto EXIT_4;
  869.     }
  870.     NewState = Traces_RecordedTrace(ChIndex, Dfa_DNoState);
  871.     if (NewState == Dfa_DNoState) {
  872.       NewState = Dfa_MakeDState();
  873.       Dfa_PutDefault(NewState, Dfa_EobDefaultState);
  874.       Traces_RecordTrace(ChIndex, Dfa_DNoState, NewState);
  875.     }
  876.     Dfa_PutTable(PrevState, Ch, NewState);
  877.     Dfa_GetStartSet(NewState, &StartSet);
  878.     Sets_Include(&StartSet, (LONGCARD)StartState);
  879.     Dfa_PutStartSet(NewState, StartSet);
  880.     PrevState = NewState;
  881.     Ch = GetCh();
  882.   } EXIT_4:;
  883.   Dfa_GetDSemantics(PrevState, &dSemantics);
  884.   Sets_Include(&dSemantics, (LONGCARD)PatternNr);
  885.   Dfa_PutDSemantics(PrevState, dSemantics);
  886.   G_1_ChIndex = L_1;
  887.   G_2_StringLength = L_2;
  888.   G_3_EndOfInput = L_3;
  889.   G_4_String = L_4;
  890. }
  891.  
  892. static void UpdateContext
  893. # ifdef __STDC__
  894. ()
  895. # else
  896. ()
  897. # endif
  898. {
  899.   SHORTCARD Pattern;
  900.   Dfa_DStateRange State1;
  901.   Dfa_DStateRange State2;
  902.   Dfa_DStateRange Max;
  903.  
  904.   if (Dfa_DStateCount > GenTabs_NodeCount) {
  905.     IO_WriteS((System_tFile)IO_StdError, (STRING)"internal Error: StateCount > NodeCount", 38L);
  906.     IO_WriteNl((System_tFile)IO_StdError);
  907.   }
  908.   {
  909.     SHORTCARD B_27 = 0, B_28 = GenTabs_PatternCount - 2;
  910.  
  911.     if (B_27 <= B_28)
  912.       for (Pattern = B_27;; Pattern += 1) {
  913.         if (GenTabs_PatternTablePtr->A[Pattern].ContextLng == GenTabs_VariableContext) {
  914.           Max = Sets_Maximum(&GenTabs_PatternTablePtr->A[Pattern].DContext);
  915.           {
  916.             SHORTINT B_29 = 1, B_30 = Max;
  917.  
  918.             if (B_29 <= B_30)
  919.               for (State1 = B_29;; State1 += 1) {
  920.                 if (Sets_IsElement((LONGCARD)State1, &GenTabs_PatternTablePtr->A[Pattern].DContext)) {
  921.                   {
  922.                     SHORTINT B_31 = 1, B_32 = Dfa_DStateCount;
  923.  
  924.                     if (B_31 <= B_32)
  925.                       for (State2 = B_31;; State2 += 1) {
  926.                         if (State1 == Dfa_GetDefault(State2)) {
  927.                           Sets_Include(&GenTabs_PatternTablePtr->A[Pattern].DContext, (LONGCARD)State2);
  928.                         }
  929.                         if (State2 >= B_32) break;
  930.                       }
  931.                   }
  932.                 }
  933.                 if (State1 >= B_30) break;
  934.               }
  935.           }
  936.         }
  937.         if (Pattern >= B_28) break;
  938.       }
  939.   }
  940. }
  941.  
  942. static void InvertMapping
  943. # ifdef __STDC__
  944. ()
  945. # else
  946. ()
  947. # endif
  948. {
  949.   SHORTCARD Pattern;
  950.   Dfa_DStateRange State;
  951.  
  952.   {
  953.     SHORTCARD B_33 = 0, B_34 = GenTabs_PatternCount;
  954.  
  955.     if (B_33 <= B_34)
  956.       for (Pattern = B_33;; Pattern += 1) {
  957.         Sets_MakeSet(&GenTabs_PatternTablePtr->A[Pattern].Finals, (LONGCARD)Dfa_DStateCount);
  958.         if (Pattern >= B_34) break;
  959.       }
  960.   }
  961.   {
  962.     SHORTINT B_35 = 1, B_36 = Dfa_DStateCount;
  963.  
  964.     if (B_35 <= B_36)
  965.       for (State = B_35;; State += 1) {
  966.         Dfa_GetDSemantics(State, &dSemantics);
  967.         if (Sets_IsEmpty(dSemantics)) {
  968.           Sets_Include(&GenTabs_PatternTablePtr->A[0].Finals, (LONGCARD)State);
  969.         } else {
  970.           Pattern = Sets_Minimum(&dSemantics);
  971.           Sets_Include(&GenTabs_PatternTablePtr->A[Pattern].Finals, (LONGCARD)State);
  972.         }
  973.         if (State >= B_36) break;
  974.       }
  975.   }
  976.   IsComputedFinals = TRUE;
  977. }
  978.  
  979. static void CheckTables
  980. # ifdef __STDC__
  981. ()
  982. # else
  983. ()
  984. # endif
  985. {
  986.   DefTable_DefRange Definition;
  987.   Idents_tIdent Ident;
  988.   SHORTCARD StartState;
  989.  
  990.   {
  991.     LONGINT B_37 = 1, B_38 = DefTable_DefCount;
  992.  
  993.     if (B_37 <= B_38)
  994.       for (Definition = B_37;; Definition += 1) {
  995.         if (DefTable_GetKind(Definition) == DefTable_Start) {
  996.           DefTable_GetStartDef(Definition, &Ident, &StartState);
  997.           CheckStartState(StartState, Ident, FALSE);
  998.           if (GenTabs_LeftJustUsed) {
  999.             CheckStartState(StartState + 1, Ident, TRUE);
  1000.           }
  1001.         }
  1002.         if (Definition >= B_38) break;
  1003.       }
  1004.   }
  1005. }
  1006.  
  1007. static void CheckStartState
  1008. # ifdef __STDC__
  1009. (SHORTCARD StartState, Idents_tIdent Ident, BOOLEAN LeftJust)
  1010. # else
  1011. (StartState, Ident, LeftJust)
  1012. SHORTCARD StartState;
  1013. Idents_tIdent Ident;
  1014. BOOLEAN LeftJust;
  1015. # endif
  1016. {
  1017.   CHAR Ch;
  1018.   Dfa_DStateRange DState;
  1019.   Sets_tSet Undefined, Semantics;
  1020.   Strings_tString String;
  1021.   INTEGER Count;
  1022.  
  1023.   Sets_MakeSet(&Undefined, ORD(Dfa_OldLastCh));
  1024.   Sets_MakeSet(&Semantics, (LONGCARD)GenTabs_PatternCount);
  1025.   Sets_Union(&Undefined, Classes_Unused);
  1026.   {
  1027.     CHAR B_39 = Dfa_FirstCh, B_40 = Dfa_LastCh;
  1028.  
  1029.     if (B_39 <= B_40)
  1030.       for (Ch = B_39;; Ch += 1) {
  1031.         DState = Dfa_GetTable((SHORTINT)StartState, Ch);
  1032.         if (DState == Dfa_DNoState) {
  1033.           if (Ch <= Classes_ClassCount) {
  1034.             Sets_Union(&Undefined, Classes_ClassMemPtr->A[Ch]);
  1035.           } else {
  1036.             Sets_Include(&Undefined, ORD(Classes_ToChar.A[Ch]));
  1037.           }
  1038.         } else {
  1039.           Dfa_GetDSemantics(DState, &Semantics);
  1040.           if (Sets_IsEmpty(Semantics)) {
  1041.             if (Ch <= Classes_ClassCount) {
  1042.               Sets_Union(&Undefined, Classes_ClassMemPtr->A[Ch]);
  1043.             } else {
  1044.               Sets_Include(&Undefined, ORD(Classes_ToChar.A[Ch]));
  1045.             }
  1046.           }
  1047.         }
  1048.         if (Ch >= B_40) break;
  1049.       }
  1050.   }
  1051.   if (!Sets_IsEmpty(Undefined)) {
  1052.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Warning: in start state ", 24L);
  1053.     Idents_GetString(Ident, &String);
  1054.     Strings_WriteS((System_tFile)IO_StdError, &String);
  1055.     if (LeftJust) {
  1056.       IO_WriteS((System_tFile)IO_StdError, (STRING)" the default action may be triggered by (left justified):", 57L);
  1057.     } else {
  1058.       IO_WriteS((System_tFile)IO_StdError, (STRING)" the default action may be triggered by:", 40L);
  1059.     }
  1060.     IO_WriteNl((System_tFile)IO_StdError);
  1061.     Count = 0;
  1062.     while (!Sets_IsEmpty(Undefined)) {
  1063.       Ch = CHR(Sets_Extract(&Undefined));
  1064.       IO_WriteC((System_tFile)IO_StdError, ' ');
  1065.       if ('!' <= Ch && Ch <= '~') {
  1066.         IO_WriteC((System_tFile)IO_StdError, '\'');
  1067.         IO_WriteC((System_tFile)IO_StdError, Ch);
  1068.         IO_WriteC((System_tFile)IO_StdError, '\'');
  1069.       } else {
  1070.         IO_WriteC((System_tFile)IO_StdError, '\\');
  1071.         IO_WriteI((System_tFile)IO_StdError, (LONGINT)ORD(Ch), 0L);
  1072.       }
  1073.       INC(Count);
  1074.       if (Count == 16) {
  1075.         IO_WriteNl((System_tFile)IO_StdError);
  1076.         Count = 0;
  1077.       }
  1078.     }
  1079.     IO_WriteNl((System_tFile)IO_StdError);
  1080.   }
  1081.   Sets_ReleaseSet(&Semantics);
  1082.   Sets_ReleaseSet(&Undefined);
  1083. }
  1084.  
  1085. static void WritePattern
  1086. # ifdef __STDC__
  1087. ()
  1088. # else
  1089. ()
  1090. # endif
  1091. {
  1092.   SHORTCARD Pattern;
  1093.  
  1094.   {
  1095.     SHORTCARD B_41 = 0, B_42 = GenTabs_PatternCount - 2;
  1096.  
  1097.     if (B_41 <= B_42)
  1098.       for (Pattern = B_41;; Pattern += 1) {
  1099.         if (GenTabs_PatternTablePtr->A[Pattern].ContextLng != GenTabs_NoContext) {
  1100.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Pattern, ContextLng", 19L);
  1101.           IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)Pattern, 5L);
  1102.           IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_PatternTablePtr->A[Pattern].ContextLng, 5L);
  1103.           if (GenTabs_PatternTablePtr->A[Pattern].ContextLng == GenTabs_VariableContext) {
  1104.             if (IsComputedNContext) {
  1105.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)" NContext ", 10L);
  1106.               Sets_WriteSet((System_tFile)IO_StdOutput, GenTabs_PatternTablePtr->A[Pattern].NContext);
  1107.             }
  1108.             if (IsComputedDContext) {
  1109.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)" DContext ", 10L);
  1110.               Sets_WriteSet((System_tFile)IO_StdOutput, GenTabs_PatternTablePtr->A[Pattern].DContext);
  1111.             }
  1112.           }
  1113.           if (IsComputedFinals) {
  1114.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)" Finals ", 8L);
  1115.             Sets_WriteSet((System_tFile)IO_StdOutput, GenTabs_PatternTablePtr->A[Pattern].Finals);
  1116.           }
  1117.           IO_WriteNl((System_tFile)IO_StdOutput);
  1118.         }
  1119.         if (Pattern >= B_42) break;
  1120.       }
  1121.   }
  1122. }
  1123.  
  1124. static void WriteStatistics
  1125. # ifdef __STDC__
  1126. ()
  1127. # else
  1128. ()
  1129. # endif
  1130. {
  1131.   IO_WriteNl((System_tFile)IO_StdOutput);
  1132.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Start States    ", 13L);
  1133.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_StartStateCount, 6L);
  1134.   IO_WriteNl((System_tFile)IO_StdOutput);
  1135.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Definitions    ", 12L);
  1136.   IO_WriteI((System_tFile)IO_StdOutput, DefTable_DefCount, 6L);
  1137.   IO_WriteNl((System_tFile)IO_StdOutput);
  1138.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Rules        ", 7L);
  1139.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_RuleCount, 6L);
  1140.   IO_WriteNl((System_tFile)IO_StdOutput);
  1141.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Patterns    ", 9L);
  1142.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_PatternCount, 6L);
  1143.   IO_WriteNl((System_tFile)IO_StdOutput);
  1144.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Classes        ", 9L);
  1145.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)ORD(Classes_ClassCount), 6L);
  1146.   IO_WriteNl((System_tFile)IO_StdOutput);
  1147.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"LastCh        ", 8L);
  1148.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)ORD(Dfa_LastCh), 6L);
  1149.   IO_WriteNl((System_tFile)IO_StdOutput);
  1150.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Transitions    ", 12L);
  1151.   IO_WriteI((System_tFile)IO_StdOutput, Nfa_TransitionCount, 6L);
  1152.   IO_WriteNl((System_tFile)IO_StdOutput);
  1153.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Leafs        ", 7L);
  1154.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_LeafCount, 6L);
  1155.   IO_WriteNl((System_tFile)IO_StdOutput);
  1156.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"NFA States    ", 11L);
  1157.   IO_WriteI((System_tFile)IO_StdOutput, Nfa_NStateCount, 6L);
  1158.   IO_WriteNl((System_tFile)IO_StdOutput);
  1159.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Minimize Savings", 16L);
  1160.   IO_WriteI((System_tFile)IO_StdOutput, Dfa_MinimizeSavings, 6L);
  1161.   IO_WriteNl((System_tFile)IO_StdOutput);
  1162.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Ambiguous States", 16L);
  1163.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)Dfa_MaxAmbiguousState, 6L);
  1164.   IO_WriteNl((System_tFile)IO_StdOutput);
  1165.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Nodes        ", 7L);
  1166.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)GenTabs_NodeCount, 6L);
  1167.   IO_WriteNl((System_tFile)IO_StdOutput);
  1168.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"DFA States    ", 11L);
  1169.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)Dfa_DStateCount, 6L);
  1170.   IO_WriteNl((System_tFile)IO_StdOutput);
  1171.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Sentinel Savings", 16L);
  1172.   IO_WriteI((System_tFile)IO_StdOutput, SentinelSavings, 6L);
  1173.   IO_WriteNl((System_tFile)IO_StdOutput);
  1174.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Default Savings    ", 16L);
  1175.   IO_WriteI((System_tFile)IO_StdOutput, Dfa_DefaultSavings, 6L);
  1176.   IO_WriteNl((System_tFile)IO_StdOutput);
  1177.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Table Entries    ", 14L);
  1178.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)ScanTabs_TableEntries, 6L);
  1179.   IO_WriteNl((System_tFile)IO_StdOutput);
  1180.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Table Size    ", 11L);
  1181.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)ScanTabs_TableSize, 6L);
  1182.   IO_WriteNl((System_tFile)IO_StdOutput);
  1183.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Memory used    ", 12L);
  1184.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)Memory_MemoryUsed, 6L);
  1185.   IO_WriteNl((System_tFile)IO_StdOutput);
  1186. }
  1187.  
  1188. void GenTabs_GenerateTables
  1189. # ifdef __STDC__
  1190. (SHORTCARD DebugLevel, BOOLEAN ReduceCaseSize, BOOLEAN Warnings, SHORTINT Optimize)
  1191. # else
  1192. (DebugLevel, ReduceCaseSize, Warnings, Optimize)
  1193. SHORTCARD DebugLevel;
  1194. BOOLEAN ReduceCaseSize, Warnings;
  1195. SHORTINT Optimize;
  1196. # endif
  1197. {
  1198.   SHORTINT i;
  1199.  
  1200.   if (DebugLevel >= 2) {
  1201.     Times_WriteStepTime((STRING)"Start        ", 7L);
  1202.   }
  1203.   IsComputedNContext = FALSE;
  1204.   IsComputedDContext = FALSE;
  1205.   IsComputedFinals = FALSE;
  1206.   INC(GenTabs_RuleCount);
  1207.   INC(GenTabs_PatternCount);
  1208.   GenTabs_EobAction = GenTabs_PatternCount;
  1209.   INC(GenTabs_RuleCount);
  1210.   INC(GenTabs_PatternCount);
  1211.   GenTabs_DefaultAction = GenTabs_PatternCount;
  1212.   GenTabs_RuleToCodeSize = GenTabs_RuleCount + 1;
  1213.   DynArray_MakeArray((ADDRESS *)&GenTabs_RuleToCodePtr, &GenTabs_RuleToCodeSize, (LONGINT)sizeof(GenTabs_CodeInfo));
  1214.   GenTabs_PatternTableSize = GenTabs_PatternCount + 1;
  1215.   DynArray_MakeArray((ADDRESS *)&GenTabs_PatternTablePtr, &GenTabs_PatternTableSize, (LONGINT)sizeof(GenTabs_PatternInfo));
  1216.   GenTabs_PatternTablePtr->A[0].ContextLng = GenTabs_NoContext;
  1217.   Sets_MakeSet(&dSemantics, (LONGCARD)GenTabs_PatternCount);
  1218.   ComputeNfa();
  1219.   if (DebugLevel >= 15) {
  1220.     Nfa_WriteNfa();
  1221.     WritePattern();
  1222.   }
  1223.   if (DebugLevel >= 2) {
  1224.     Times_WriteStepTime((STRING)"ComputeNfa    ", 11L);
  1225.   }
  1226.   ComputeDfa();
  1227.   if (DebugLevel >= 14) {
  1228.     Dfa_WriteDfa();
  1229.     WritePattern();
  1230.   }
  1231.   if (DebugLevel >= 2) {
  1232.     Times_WriteStepTime((STRING)"ComputeDfa    ", 11L);
  1233.   }
  1234.   Dfa_MinimizeDfa();
  1235.   if (DebugLevel >= 13) {
  1236.     Dfa_WriteDfa();
  1237.     WritePattern();
  1238.   }
  1239.   if (DebugLevel >= 2) {
  1240.     Times_WriteStepTime((STRING)"MinimizeDfa    ", 12L);
  1241.   }
  1242.   Dfa_EobDefaultState = Dfa_MakeDState();
  1243.   Dfa_ComputeSuccGraph();
  1244.   if (DebugLevel >= 2) {
  1245.     Times_WriteStepTime((STRING)"ComputeSuccGraph", 16L);
  1246.   }
  1247.   Dfa_ComputeAmbiguousStates();
  1248.   if (DebugLevel >= 2) {
  1249.     Times_WriteStepTime((STRING)"ComputeAmbiguous", 16L);
  1250.   }
  1251.   Dfa_ComputeCyclicStates();
  1252.   if (DebugLevel >= 12) {
  1253.     Sets_WriteSet((System_tFile)IO_StdOutput, Dfa_AmbiguousStates);
  1254.     IO_WriteNl((System_tFile)IO_StdOutput);
  1255.     Sets_WriteSet((System_tFile)IO_StdOutput, Dfa_CyclicStates);
  1256.     IO_WriteNl((System_tFile)IO_StdOutput);
  1257.   }
  1258.   if (DebugLevel >= 2) {
  1259.     Times_WriteStepTime((STRING)"ComputeCyclicSta", 16L);
  1260.   }
  1261.   Dfa_ComputeStartSets();
  1262.   if (DebugLevel >= 11) {
  1263.     Dfa_WriteDfa();
  1264.     WritePattern();
  1265.   }
  1266.   if (DebugLevel >= 2) {
  1267.     Times_WriteStepTime((STRING)"ComputeStartSets", 16L);
  1268.   }
  1269.   Dfa_EobState = Dfa_MakeDState();
  1270.   Sets_AssignElmt(&dSemantics, (LONGCARD)GenTabs_EobAction);
  1271.   Dfa_PutDSemantics(Dfa_EobState, dSemantics);
  1272.   Sets_AssignElmt(&dSemantics, (LONGCARD)GenTabs_DefaultAction);
  1273.   Dfa_PutDSemantics(Dfa_MakeDState(), dSemantics);
  1274.   AddConstantREs();
  1275.   if (DebugLevel >= 10) {
  1276.     Dfa_WriteDfa();
  1277.     WritePattern();
  1278.   }
  1279.   if (DebugLevel >= 2) {
  1280.     Times_WriteStepTime((STRING)"AddConstantREs    ", 15L);
  1281.   }
  1282.   UpdateContext();
  1283.   if (DebugLevel >= 9) {
  1284.     Dfa_WriteDfa();
  1285.     WritePattern();
  1286.   }
  1287.   if (DebugLevel >= 2) {
  1288.     Times_WriteStepTime((STRING)"UpdateContext    ", 14L);
  1289.   }
  1290.   Dfa_SaveEobTransitions();
  1291.   if (DebugLevel >= 8) {
  1292.     Dfa_WriteDfa();
  1293.     WritePattern();
  1294.   }
  1295.   if (DebugLevel >= 2) {
  1296.     Times_WriteStepTime((STRING)"SaveEobTransitio", 16L);
  1297.   }
  1298.   SaveSentinels();
  1299.   if (DebugLevel >= 7) {
  1300.     Dfa_WriteDfa();
  1301.     WritePattern();
  1302.   }
  1303.   if (DebugLevel >= 2) {
  1304.     Times_WriteStepTime((STRING)"SaveSentinels    ", 14L);
  1305.   }
  1306.   if (Optimize > 0) {
  1307.     i = 1;
  1308.     while (i <= Dfa_MaxAmbiguousState) {
  1309.       Dfa_ComputeDefaults(i, (SHORTINT)General_Min((LONGINT)Dfa_MaxAmbiguousState, (LONGINT)(i + Optimize - 1)));
  1310.       if (DebugLevel >= 2) {
  1311.         Times_WriteStepTime((STRING)"ComputeDefaults    ", 16L);
  1312.       }
  1313.       INC1(i, Optimize);
  1314.     }
  1315.   }
  1316.   if (DebugLevel >= 6) {
  1317.     Dfa_WriteDfa();
  1318.     WritePattern();
  1319.   }
  1320.   InvertMapping();
  1321.   if (DebugLevel >= 5) {
  1322.     WritePattern();
  1323.   }
  1324.   if (DebugLevel >= 2) {
  1325.     Times_WriteStepTime((STRING)"InvertMapping    ", 14L);
  1326.   }
  1327.   ScanTabs_MakeTables(ReduceCaseSize);
  1328.   if (DebugLevel >= 2) {
  1329.     Times_WriteStepTime((STRING)"MakeTables    ", 11L);
  1330.   }
  1331.   ScanTabs_CompressTables(Optimize);
  1332.   if (DebugLevel >= 4) {
  1333.     ScanTabs_WriteTables();
  1334.   }
  1335.   if (DebugLevel >= 2) {
  1336.     Times_WriteStepTime((STRING)"CompressTables    ", 15L);
  1337.   }
  1338.   if (ScanGen_Language == ScanGen_Modula) {
  1339.     ScanTabs_PutTables(ReduceCaseSize);
  1340.     if (DebugLevel >= 2) {
  1341.       Times_WriteStepTime((STRING)"PutTables    ", 10L);
  1342.     }
  1343.   }
  1344.   if (DebugLevel >= 3) {
  1345.     ScanTabs_QueryTables();
  1346.   }
  1347.   if (Warnings) {
  1348.     CheckTables();
  1349.     if (DebugLevel >= 2) {
  1350.       Times_WriteStepTime((STRING)"CheckTables    ", 12L);
  1351.     }
  1352.   }
  1353.   if (DebugLevel >= 1) {
  1354.     WriteStatistics();
  1355.   }
  1356. }
  1357.  
  1358. void BEGIN_GenTabs()
  1359. {
  1360.   static BOOLEAN has_been_called = FALSE;
  1361.  
  1362.   if (!has_been_called) {
  1363.     has_been_called = TRUE;
  1364.  
  1365.     BEGIN_Tree();
  1366.     BEGIN_Texts();
  1367.     BEGIN_Sets();
  1368.     BEGIN_Positions();
  1369.     BEGIN_General();
  1370.     BEGIN_Memory();
  1371.     BEGIN_DynArray();
  1372.     BEGIN_Strings();
  1373.     BEGIN_StringMem();
  1374.     BEGIN_Times();
  1375.     BEGIN_Sets();
  1376.     BEGIN_IO();
  1377.     BEGIN_Layout();
  1378.     BEGIN_DefTable();
  1379.     BEGIN_Tree();
  1380.     BEGIN_Nfa();
  1381.     BEGIN_Dfa();
  1382.     BEGIN_Traces();
  1383.     BEGIN_ScanTabs();
  1384.     BEGIN_ScanGen();
  1385.     BEGIN_Classes();
  1386.     BEGIN_Strings();
  1387.     BEGIN_Idents();
  1388.  
  1389.   }
  1390. }
  1391.